home *** CD-ROM | disk | FTP | other *** search
/ This Disc Bytes! / Power Computing - The Disc 2 - This Disc Bytes.ISO / pc / codewarr / macossup / headers / universa / ocemessa.h < prev    next >
Text File  |  1995-07-06  |  32KB  |  1,146 lines
  1. /*
  2.      File:        OCEMessaging.h
  3.  
  4.      Contains:    Apple Open Collaboration Environment Messaging Interfaces.
  5.  
  6.      Version:    Technology:    AOCE Toolbox 1.02
  7.                  Package:    Universal Interfaces 2.1 in “MPW Latest” on ETO #18
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. */
  19.  
  20. #ifndef __OCEMESSAGING__
  21. #define __OCEMESSAGING__
  22.  
  23.  
  24. #ifndef __APPLEEVENTS__
  25. #include <AppleEvents.h>
  26. #endif
  27. /*    #include <Errors.h>                                            */
  28. /*        #include <ConditionalMacros.h>                            */
  29. /*    #include <Types.h>                                            */
  30. /*    #include <Memory.h>                                            */
  31. /*        #include <MixedMode.h>                                    */
  32. /*    #include <OSUtils.h>                                        */
  33. /*    #include <Events.h>                                            */
  34. /*        #include <Quickdraw.h>                                    */
  35. /*            #include <QuickdrawText.h>                            */
  36. /*    #include <EPPC.h>                                            */
  37. /*        #include <AppleTalk.h>                                    */
  38. /*        #include <Files.h>                                        */
  39. /*            #include <Finder.h>                                    */
  40. /*        #include <PPCToolbox.h>                                    */
  41. /*        #include <Processes.h>                                    */
  42. /*    #include <Notification.h>                                    */
  43.  
  44. #ifndef __FILES__
  45. #include <Files.h>
  46. #endif
  47.  
  48. #ifndef __TYPES__
  49. #include <Types.h>
  50. #endif
  51.  
  52. #ifndef __DIGITALSIGNATURE__
  53. #include <DigitalSignature.h>
  54. #endif
  55.  
  56. #ifndef __OCE__
  57. #include <OCE.h>
  58. #endif
  59. /*    #include <Aliases.h>                                        */
  60. /*    #include <Script.h>                                            */
  61. /*        #include <IntlResources.h>                                */
  62.  
  63. #ifndef __OCEAUTHDIR__
  64. #include <OCEAuthDir.h>
  65. #endif
  66.  
  67. #ifdef __cplusplus
  68. extern "C" {
  69. #endif
  70.  
  71. #if PRAGMA_ALIGN_SUPPORTED
  72. #pragma options align=mac68k
  73. #endif
  74.  
  75. #if PRAGMA_IMPORT_SUPPORTED
  76. #pragma import on
  77. #endif
  78.  
  79. /******************************************************************************/
  80. /* Definitions common to OCEMessaging and to OCEMail. These relate to addressing,
  81. message ids and priorities, etc. */
  82. /* Values of IPMPriority */
  83.  
  84. enum {
  85.     kIPMAnyPriority                = 0,                            /* FOR FILTER ONLY */
  86.     kIPMNormalPriority            = 1,
  87.     kIPMLowPriority,
  88.     kIPMHighPriority
  89. };
  90.  
  91. typedef Byte IPMPriority;
  92.  
  93. /* Values of IPMAccessMode */
  94.  
  95. enum {
  96.     kIPMAtMark,
  97.     kIPMFromStart,
  98.     kIPMFromLEOM,
  99.     kIPMFromMark
  100. };
  101.  
  102. typedef unsigned short IPMAccessMode;
  103.  
  104.  
  105. enum {
  106.     kIPMUpdateMsgBit            = 4,
  107.     kIPMNewMsgBit                = 5,
  108.     kIPMDeleteMsgBit            = 6
  109. };
  110.  
  111. /* Values of IPMNotificationType */
  112. enum {
  113.     kIPMUpdateMsgMask            = 1 << kIPMUpdateMsgBit,
  114.     kIPMNewMsgMask                = 1 << kIPMNewMsgBit,
  115.     kIPMDeleteMsgMask            = 1 << kIPMDeleteMsgBit
  116. };
  117.  
  118. typedef Byte IPMNotificationType;
  119.  
  120. /* Values of IPMSenderTag */
  121.  
  122. enum {
  123.     kIPMSenderRStringTag,
  124.     kIPMSenderRecordIDTag
  125. };
  126.  
  127. typedef unsigned short IPMSenderTag;
  128.  
  129.  
  130. enum {
  131.     kIPMFromDistListBit            = 0,
  132.     kIPMDummyRecBit                = 1,
  133.     kIPMFeedbackRecBit            = 2,                            /* should be redirected to feedback queue */
  134.     kIPMReporterRecBit            = 3,                            /* should be redirected to reporter original queue */
  135.     kIPMBCCRecBit                = 4                                /* this recipient is blind to all recipients of message */
  136. };
  137.  
  138. /* Values of OCERecipientOffsetFlags */
  139. enum {
  140.     kIPMFromDistListMask        = 1 << kIPMFromDistListBit,
  141.     kIPMDummyRecMask            = 1 << kIPMDummyRecBit,
  142.     kIPMFeedbackRecMask            = 1 << kIPMFeedbackRecBit,
  143.     kIPMReporterRecMask            = 1 << kIPMReporterRecBit,
  144.     kIPMBCCRecMask                = 1 << kIPMBCCRecBit
  145. };
  146.  
  147. typedef Byte OCERecipientOffsetFlags;
  148.  
  149. struct OCECreatorType {
  150.     OSType                            msgCreator;
  151.     OSType                            msgType;
  152. };
  153. typedef struct OCECreatorType OCECreatorType;
  154.  
  155.  
  156. enum {
  157.     kIPMTypeWildCard            = 'ipmw',
  158.     kIPMFamilyUnspecified        = 0,
  159.     kIPMFamilyWildCard            = 0x3F3F3F3FL,                    /* '??^ 
  160.  
  161.     * well known signature */
  162.     kIPMSignature                = 'ipms',                        /* base type 
  163.  
  164.     * well known message types */
  165.     kIPMReportNotify            = 'rptn',                        /* routing feedback
  166.  
  167.     * well known message block types */
  168.     kIPMEnclosedMsgType            = 'emsg',                        /* enclosed (nested) message */
  169.     kIPMReportInfo                = 'rpti',                        /* recipient information */
  170.     kIPMDigitalSignature        = 'dsig'
  171. };
  172.  
  173. /* Values of IPMMsgFormat */
  174. enum {
  175.     kIPMOSFormatType            = 1,
  176.     kIPMStringFormatType        = 2
  177. };
  178.  
  179. typedef unsigned short IPMMsgFormat;
  180.  
  181. typedef Str32 IPMStringMsgType;
  182.  
  183. union TheType {
  184.     OCECreatorType                    msgOSType;
  185.     IPMStringMsgType                msgStrType;
  186. };
  187. typedef union TheType TheType;
  188.  
  189. struct IPMMsgType {
  190.     IPMMsgFormat                    format;                        /* IPMMsgFormat*/
  191.     TheType                            theType;
  192. };
  193. typedef struct IPMMsgType IPMMsgType;
  194.  
  195. /*
  196. Following are the known extension values for IPM addresses handled by Apple.
  197. We define the definition of the entn extension below.
  198. */
  199.  
  200. enum {
  201.     kOCEalanXtn                    = 'alan',
  202.     kOCEentnXtn                    = 'entn',                        /* entn = entity name (aka DSSpec) */
  203.     kOCEaphnXtn                    = 'aphn'
  204. };
  205.  
  206. /*
  207. Following are the specific definitions for the extension for the standard
  208. OCEMail 'entn' addresses.  [Note, the actual extension is formatted as in
  209. IPMEntityNameExtension.]
  210. */
  211. /* entn extension forms */
  212. enum {
  213.     kOCEAddrXtn                    = 'addr',
  214.     kOCEQnamXtn                    = 'qnam',
  215.     kOCEAttrXtn                    = 'attr',                        /* an attribute specification */
  216.     kOCESpAtXtn                    = 'spat'
  217. };
  218.  
  219. /*
  220. Following are the specific definitions for standard
  221. OCEMail 'aphn' extension value.  
  222.  
  223. All RStrings here are packed (e.g. truncated to length) and even padded (e.g.
  224. if length odd, then a pad byte (zero) should be introduced before the next field).
  225.  
  226. The extension value is in the packed form of the following structure:
  227.     RString        phoneNumber;
  228.     RString        modemType;
  229.     Str32        queueuName;
  230.  
  231. The body of phoneNumber compound RString is in the packed form of the following structure:
  232.     short         subType;
  233.     RString     countryCode;                // used when subType == kOCEUseHandyDial
  234.     RString        areaCode;                    // used when subType == kOCEUseHandyDial
  235.     RString        phone;                        // used when subType == kOCEUseHandyDial
  236.     RString        postFix;                    // used when subType == kOCEUseHandyDial
  237.     RString        nonHandyDialString;            // used when subType == kOCEDontUseHandyDial
  238. */
  239. /* phoneNumber sub type constants */
  240. enum {
  241.     kOCEUseHandyDial            = 1,
  242.     kOCEDontUseHandyDial        = 2
  243. };
  244.  
  245. /* FORMAT OF A PACKED FORM RECIPIENT */
  246. #define OCEPackedRecipientHeader  \
  247.     unsigned short    dataLength;
  248. struct ProtoOCEPackedRecipient {
  249.     unsigned short                    dataLength;
  250. };
  251. typedef struct ProtoOCEPackedRecipient ProtoOCEPackedRecipient;
  252.  
  253.  
  254. enum {
  255.     kOCEPackedRecipientMaxBytes    = (4096 - sizeof(ProtoOCEPackedRecipient))
  256. };
  257.  
  258. struct OCEPackedRecipient {
  259.     unsigned short                    dataLength;
  260.     Byte                            data[kOCEPackedRecipientMaxBytes];
  261. };
  262. typedef struct OCEPackedRecipient OCEPackedRecipient;
  263.  
  264. struct IPMEntnQueueExtension {
  265.     Str32                            queueName;
  266. };
  267. typedef struct IPMEntnQueueExtension IPMEntnQueueExtension;
  268.  
  269. /* kOCEAttrXtn */
  270. struct IPMEntnAttributeExtension {
  271.     AttributeType                    attributeName;
  272. };
  273. typedef struct IPMEntnAttributeExtension IPMEntnAttributeExtension;
  274.  
  275. /* kOCESpAtXtn */
  276. struct IPMEntnSpecificAttributeExtension {
  277.     AttributeCreationID                attributeCreationID;
  278.     AttributeType                    attributeName;
  279. };
  280. typedef struct IPMEntnSpecificAttributeExtension IPMEntnSpecificAttributeExtension;
  281.  
  282. /* All IPM entn extensions fit within the following */
  283. struct IPMEntityNameExtension {
  284.     OSType                            subExtensionType;
  285.     union {
  286.         IPMEntnSpecificAttributeExtension specificAttribute;
  287.         IPMEntnAttributeExtension        attribute;
  288.         IPMEntnQueueExtension            queue;
  289.     }                                u;
  290. };
  291. typedef struct IPMEntityNameExtension IPMEntityNameExtension;
  292.  
  293. /* addresses with kIPMNBPXtn should specify this nbp type */
  294. #define kIPMWSReceiverNBPType "\pMsgReceiver" 
  295. struct IPMMsgID {
  296.     unsigned long                    id[4];
  297. };
  298. typedef struct IPMMsgID IPMMsgID;
  299.  
  300. /* Values of IPMHeaderSelector */
  301.  
  302. enum {
  303.     kIPMTOC                        = 0,
  304.     kIPMSender                    = 1,
  305.     kIPMProcessHint                = 2,
  306.     kIPMMessageTitle            = 3,
  307.     kIPMMessageType                = 4,
  308.     kIPMFixedInfo                = 7
  309. };
  310.  
  311. typedef Byte IPMHeaderSelector;
  312.  
  313. union TheSender {
  314.     RString                            rString;
  315.     PackedRecordID                    rid;
  316. };
  317. typedef union TheSender TheSender;
  318.  
  319. struct IPMSender {
  320.     IPMSenderTag                    sendTag;
  321.     TheSender                        theSender;
  322. };
  323. typedef struct IPMSender IPMSender;
  324.  
  325. /******************************************************************************/
  326. /* Definitions specific to OCEMessaging */
  327. typedef unsigned long IPMContextRef;
  328.  
  329. typedef unsigned long IPMQueueRef;
  330.  
  331. typedef unsigned long IPMMsgRef;
  332.  
  333. typedef unsigned long IPMSeqNum;
  334.  
  335. typedef Str32 IPMProcHint;
  336.  
  337. typedef Str32 IPMQueueName;
  338.  
  339. typedef pascal void (*IPMNoteProcPtr)(IPMQueueRef queue, IPMSeqNum seqNum, IPMNotificationType notificationType, unsigned long userData);
  340.  
  341. #if GENERATINGCFM
  342. typedef UniversalProcPtr IPMNoteUPP;
  343. #else
  344. typedef IPMNoteProcPtr IPMNoteUPP;
  345. #endif
  346.  
  347. enum {
  348.     uppIPMNoteProcInfo = kPascalStackBased
  349.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(IPMQueueRef)))
  350.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(IPMSeqNum)))
  351.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(IPMNotificationType)))
  352.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(unsigned long)))
  353. };
  354.  
  355. #if GENERATINGCFM
  356. #define NewIPMNoteProc(userRoutine)        \
  357.         (IPMNoteUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppIPMNoteProcInfo, GetCurrentArchitecture())
  358. #else
  359. #define NewIPMNoteProc(userRoutine)        \
  360.         ((IPMNoteUPP) (userRoutine))
  361. #endif
  362.  
  363. #if GENERATINGCFM
  364. #define CallIPMNoteProc(userRoutine, queue, seqNum, notificationType, userData)        \
  365.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppIPMNoteProcInfo, (queue), (seqNum), (notificationType), (userData))
  366. #else
  367. #define CallIPMNoteProc(userRoutine, queue, seqNum, notificationType, userData)        \
  368.         (*(userRoutine))((queue), (seqNum), (notificationType), (userData))
  369. #endif
  370.  
  371. struct IPMFixedHdrInfo {
  372.     unsigned short                    version;
  373.     Boolean                            authenticated;
  374.     Boolean                            signatureEnclosed;            /*  digital signature enclosed */
  375.     unsigned long                    msgSize;
  376.     IPMNotificationType                notification;
  377.     IPMPriority                        priority;
  378.     unsigned short                    blockCount;
  379.     unsigned short                    originalRcptCount;            /*        original number of recipients */
  380.     unsigned long                    refCon;                        /*        Client defined data */
  381.     unsigned short                    reserved;
  382.     UTCTime                            creationTime;                /*        Time when it was created */
  383.     IPMMsgID                        msgID;
  384.     OSType                            family;                        /* family this msg belongs (e.g. mail) */
  385. };
  386. typedef struct IPMFixedHdrInfo IPMFixedHdrInfo;
  387.  
  388.  
  389. enum {
  390.     kIPMDeliveryNotificationBit    = 0,
  391.     kIPMNonDeliveryNotificationBit = 1,
  392.     kIPMEncloseOriginalBit        = 2,
  393.     kIPMSummaryReportBit        = 3,
  394. /* modify enclose original to only on error */
  395.     kIPMOriginalOnlyOnErrorBit    = 4
  396. };
  397.  
  398. enum {
  399.     kIPMNoNotificationMask        = 0x00,
  400.     kIPMDeliveryNotificationMask = 1 << kIPMDeliveryNotificationBit,
  401.     kIPMNonDeliveryNotificationMask = 1 << kIPMNonDeliveryNotificationBit,
  402.     kIPMDontEncloseOriginalMask    = 0x00,
  403.     kIPMEncloseOriginalMask        = 1 << kIPMEncloseOriginalBit,
  404.     kIPMImmediateReportMask        = 0x00,
  405.     kIPMSummaryReportMask        = 1 << kIPMSummaryReportBit,
  406.     kIPMOriginalOnlyOnErrorMask    = 1 << kIPMOriginalOnlyOnErrorBit,
  407.     kIPMEncloseOriginalOnErrorMask = (kIPMOriginalOnlyOnErrorMask | kIPMEncloseOriginalMask)
  408. };
  409.  
  410. /* standard Non delivery codes */
  411. enum {
  412.     kIPMNoSuchRecipient            = 0x0001,
  413.     kIPMRecipientMalformed        = 0x0002,
  414.     kIPMRecipientAmbiguous        = 0x0003,
  415.     kIPMRecipientAccessDenied    = 0x0004,
  416.     kIPMGroupExpansionProblem    = 0x0005,
  417.     kIPMMsgUnreadable            = 0x0006,
  418.     kIPMMsgExpired                = 0x0007,
  419.     kIPMMsgNoTranslatableContent = 0x0008,
  420.     kIPMRecipientReqStdCont        = 0x0009,
  421.     kIPMRecipientReqSnapShot    = 0x000A,
  422.     kIPMNoTransferDiskFull        = 0x000B,
  423.     kIPMNoTransferMsgRejectedbyDest = 0x000C,
  424.     kIPMNoTransferMsgTooLarge    = 0x000D
  425. };
  426.  
  427. /*************************************************************************/
  428. /*
  429. This is the structure that will be returned by enumerate and getmsginfo
  430. This definition is just to give you a template, the position of msgType
  431. is variable since this is a packed structure.  procHint and msgType are
  432. packed and even length padded.
  433.  
  434. * master message info */
  435. struct IPMMsgInfo {
  436.     IPMSeqNum                        sequenceNum;
  437.     unsigned long                    userData;
  438.     unsigned short                    respIndex;
  439.     SInt8                            padByte;
  440.     IPMPriority                        priority;
  441.     unsigned long                    msgSize;
  442.     unsigned short                    originalRcptCount;
  443.     unsigned short                    reserved;
  444.     UTCTime                            creationTime;
  445.     IPMMsgID                        msgID;
  446.     OSType                            family;                        /* family this msg belongs (e.g. mail) */
  447.     IPMProcHint                        procHint;
  448.     SInt8                            filler2;
  449.     IPMMsgType                        msgType;
  450. };
  451. typedef struct IPMMsgInfo IPMMsgInfo;
  452.  
  453. typedef OCECreatorType IPMBlockType;
  454.  
  455. struct IPMTOC {
  456.     IPMBlockType                    blockType;
  457.     long                            blockOffset;
  458.     unsigned long                    blockSize;
  459.     unsigned long                    blockRefCon;
  460. };
  461. typedef struct IPMTOC IPMTOC;
  462.  
  463. /*
  464. The following structure is just to describe the layout of the SingleFilter.
  465. Each field should be packed and word aligned when passed to the IPM ToolBox.
  466. */
  467. struct IPMSingleFilter {
  468.     IPMPriority                        priority;
  469.     SInt8                            padByte;
  470.     OSType                            family;                        /* family this msg belongs (e.g. mail), '??^ for all */
  471.     ScriptCode                        script;                        /* Language Identifier */
  472.     IPMProcHint                        hint;
  473.     SInt8                            filler2;
  474.     IPMMsgType                        msgType;
  475. };
  476. typedef struct IPMSingleFilter IPMSingleFilter;
  477.  
  478. struct IPMFilter {
  479.     unsigned short                    count;
  480.     IPMSingleFilter                    sFilters[1];
  481. };
  482. typedef struct IPMFilter IPMFilter;
  483.  
  484. /*************************************************************************
  485. Following structures define the “start” of a recipient report block and the
  486. elements of the array respectively.
  487. */
  488. struct IPMReportBlockHeader {
  489.     IPMMsgID                        msgID;                        /* message id of the original */
  490.     UTCTime                            creationTime;                /* creation time of the report */
  491. };
  492. typedef struct IPMReportBlockHeader IPMReportBlockHeader;
  493.  
  494. struct OCERecipientReport {
  495.     unsigned short                    rcptIndex;                    /* index of recipient in original message */
  496.     OSErr                            result;                        /* result of sending letter to this recipient*/
  497. };
  498. typedef struct OCERecipientReport OCERecipientReport;
  499.  
  500. /*************************************************************************/
  501. typedef union IPMParamBlock IPMParamBlock;
  502.  
  503. typedef IPMParamBlock *IPMParamBlockPtr;
  504.  
  505. typedef pascal void (*IPMIOCompletionProcPtr)(IPMParamBlockPtr paramBlock);
  506.  
  507. #if GENERATINGCFM
  508. typedef UniversalProcPtr IPMIOCompletionUPP;
  509. #else
  510. typedef IPMIOCompletionProcPtr IPMIOCompletionUPP;
  511. #endif
  512.  
  513. #define IPMParamHeader             \
  514.     Ptr    qLink;                        \
  515.     long    reservedH1;                \
  516.     long    reservedH2;                \
  517.     IPMIOCompletionUPP    ioCompletion;     \
  518.     OSErr    ioResult;                \
  519.     long    saveA5;                    \
  520.     short    reqCode;
  521. struct IPMOpenContextPB {
  522.     Ptr                                qLink;
  523.     long                            reservedH1;
  524.     long                            reservedH2;
  525.     IPMIOCompletionUPP                ioCompletion;
  526.     OSErr                            ioResult;
  527.     long                            saveA5;
  528.     short                            reqCode;
  529.     IPMContextRef                    contextRef;                    /* <--  Context reference to be used in further calls*/
  530. };
  531. typedef struct IPMOpenContextPB IPMOpenContextPB;
  532.  
  533. typedef IPMOpenContextPB IPMCloseContextPB;
  534.  
  535. struct IPMCreateQueuePB {
  536.     Ptr                                qLink;
  537.     long                            reservedH1;
  538.     long                            reservedH2;
  539.     IPMIOCompletionUPP                ioCompletion;
  540.     OSErr                            ioResult;
  541.     long                            saveA5;
  542.     short                            reqCode;
  543.     long                            filler1;
  544.     OCERecipient                    *queue;
  545.     AuthIdentity                    identity;                    /* used only if queue is remote */
  546.     PackedRecordID                    *owner;                        /* used only if queue is remote */
  547. };
  548. typedef struct IPMCreateQueuePB IPMCreateQueuePB;
  549.  
  550. /* For createqueue and deletequeue only queue and identity are used */
  551. typedef IPMCreateQueuePB IPMDeleteQueuePB;
  552.  
  553. struct IPMOpenQueuePB {
  554.     Ptr                                qLink;
  555.     long                            reservedH1;
  556.     long                            reservedH2;
  557.     IPMIOCompletionUPP                ioCompletion;
  558.     OSErr                            ioResult;
  559.     long                            saveA5;
  560.     short                            reqCode;
  561.     IPMContextRef                    contextRef;
  562.     OCERecipient                    *queue;
  563.     AuthIdentity                    identity;
  564.     IPMFilter                        *filter;
  565.     IPMQueueRef                        newQueueRef;
  566.     IPMNoteUPP                        notificationProc;
  567.     unsigned long                    userData;
  568.     IPMNotificationType                noteType;
  569.     Byte                            padByte;
  570.     long                            reserved;
  571.     long                            reserved2;
  572. };
  573. typedef struct IPMOpenQueuePB IPMOpenQueuePB;
  574.  
  575. struct IPMCloseQueuePB {
  576.     Ptr                                qLink;
  577.     long                            reservedH1;
  578.     long                            reservedH2;
  579.     IPMIOCompletionUPP                ioCompletion;
  580.     OSErr                            ioResult;
  581.     long                            saveA5;
  582.     short                            reqCode;
  583.     IPMQueueRef                        queueRef;
  584. };
  585. typedef struct IPMCloseQueuePB IPMCloseQueuePB;
  586.  
  587. struct IPMEnumerateQueuePB {
  588.     Ptr                                qLink;
  589.     long                            reservedH1;
  590.     long                            reservedH2;
  591.     IPMIOCompletionUPP                ioCompletion;
  592.     OSErr                            ioResult;
  593.     long                            saveA5;
  594.     short                            reqCode;
  595.     IPMQueueRef                        queueRef;
  596.     IPMSeqNum                        startSeqNum;
  597.     Boolean                            getProcHint;
  598.     Boolean                            getMsgType;
  599.     short                            filler;
  600.     IPMFilter                        *filter;
  601.     unsigned short                    numToGet;
  602.     unsigned short                    numGotten;
  603.     unsigned long                    enumCount;
  604.     Ptr                                enumBuffer;                    /* will be packed array of IPMMsgInfo */
  605.     unsigned long                    actEnumCount;
  606. };
  607. typedef struct IPMEnumerateQueuePB IPMEnumerateQueuePB;
  608.  
  609. typedef IPMEnumerateQueuePB IPMChangeQueueFilterPB;
  610.  
  611. struct IPMDeleteMsgRangePB {
  612.     Ptr                                qLink;
  613.     long                            reservedH1;
  614.     long                            reservedH2;
  615.     IPMIOCompletionUPP                ioCompletion;
  616.     OSErr                            ioResult;
  617.     long                            saveA5;
  618.     short                            reqCode;
  619.     IPMQueueRef                        queueRef;
  620.     IPMSeqNum                        startSeqNum;
  621.     IPMSeqNum                        endSeqNum;
  622.     IPMSeqNum                        lastSeqNum;
  623. };
  624. typedef struct IPMDeleteMsgRangePB IPMDeleteMsgRangePB;
  625.  
  626. struct IPMOpenMsgPB {
  627.     Ptr                                qLink;
  628.     long                            reservedH1;
  629.     long                            reservedH2;
  630.     IPMIOCompletionUPP                ioCompletion;
  631.     OSErr                            ioResult;
  632.     long                            saveA5;
  633.     short                            reqCode;
  634.     IPMQueueRef                        queueRef;
  635.     IPMSeqNum                        sequenceNum;
  636.     IPMMsgRef                        newMsgRef;
  637.     IPMSeqNum                        actualSeqNum;
  638.     Boolean                            exactMatch;
  639.     Byte                            padByte;
  640.     long                            reserved;
  641. };
  642. typedef struct IPMOpenMsgPB IPMOpenMsgPB;
  643.  
  644. struct IPMOpenHFSMsgPB {
  645.     Ptr                                qLink;
  646.     long                            reservedH1;
  647.     long                            reservedH2;
  648.     IPMIOCompletionUPP                ioCompletion;
  649.     OSErr                            ioResult;
  650.     long                            saveA5;
  651.     short                            reqCode;
  652.     FSSpec                            *hfsPath;
  653.     long                            filler;
  654.     IPMMsgRef                        newMsgRef;
  655.     long                            filler2;
  656.     Byte                            filler3;
  657.     Boolean                            filler4;
  658.     long                            reserved;
  659. };
  660. typedef struct IPMOpenHFSMsgPB IPMOpenHFSMsgPB;
  661.  
  662. struct IPMOpenBlockAsMsgPB {
  663.     Ptr                                qLink;
  664.     long                            reservedH1;
  665.     long                            reservedH2;
  666.     IPMIOCompletionUPP                ioCompletion;
  667.     OSErr                            ioResult;
  668.     long                            saveA5;
  669.     short                            reqCode;
  670.     IPMMsgRef                        msgRef;
  671.     unsigned long                    filler;
  672.     IPMMsgRef                        newMsgRef;
  673.     unsigned short                    filler2[7];
  674.     unsigned short                    blockIndex;
  675. };
  676. typedef struct IPMOpenBlockAsMsgPB IPMOpenBlockAsMsgPB;
  677.  
  678. struct IPMCloseMsgPB {
  679.     Ptr                                qLink;
  680.     long                            reservedH1;
  681.     long                            reservedH2;
  682.     IPMIOCompletionUPP                ioCompletion;
  683.     OSErr                            ioResult;
  684.     long                            saveA5;
  685.     short                            reqCode;
  686.     IPMMsgRef                        msgRef;
  687.     Boolean                            deleteMsg;
  688.     Boolean                            filler1;
  689. };
  690. typedef struct IPMCloseMsgPB IPMCloseMsgPB;
  691.  
  692. struct IPMGetMsgInfoPB {
  693.     Ptr                                qLink;
  694.     long                            reservedH1;
  695.     long                            reservedH2;
  696.     IPMIOCompletionUPP                ioCompletion;
  697.     OSErr                            ioResult;
  698.     long                            saveA5;
  699.     short                            reqCode;
  700.     IPMMsgRef                        msgRef;
  701.     IPMMsgInfo                        *info;
  702. };
  703. typedef struct IPMGetMsgInfoPB IPMGetMsgInfoPB;
  704.  
  705. struct IPMReadHeaderPB {
  706.     Ptr                                qLink;
  707.     long                            reservedH1;
  708.     long                            reservedH2;
  709.     IPMIOCompletionUPP                ioCompletion;
  710.     OSErr                            ioResult;
  711.     long                            saveA5;
  712.     short                            reqCode;
  713.     IPMMsgRef                        msgRef;
  714.     unsigned short                    fieldSelector;
  715.     long                            offset;
  716.     unsigned long                    count;
  717.     Ptr                                buffer;
  718.     unsigned long                    actualCount;
  719.     unsigned short                    filler;
  720.     unsigned long                    remaining;
  721. };
  722. typedef struct IPMReadHeaderPB IPMReadHeaderPB;
  723.  
  724. struct IPMReadRecipientPB {
  725.     Ptr                                qLink;
  726.     long                            reservedH1;
  727.     long                            reservedH2;
  728.     IPMIOCompletionUPP                ioCompletion;
  729.     OSErr                            ioResult;
  730.     long                            saveA5;
  731.     short                            reqCode;
  732.     IPMMsgRef                        msgRef;
  733.     unsigned short                    rcptIndex;
  734.     long                            offset;
  735.     unsigned long                    count;
  736.     Ptr                                buffer;
  737.     unsigned long                    actualCount;
  738.     short                            reserved;                    /* must be zero */
  739.     unsigned long                    remaining;
  740.     unsigned short                    originalIndex;
  741.     OCERecipientOffsetFlags            recipientOffsetFlags;
  742.     Boolean                            filler1;
  743. };
  744. typedef struct IPMReadRecipientPB IPMReadRecipientPB;
  745.  
  746. /*
  747. replyQueue works like recipient. [can no longer read it via ReadHeader]
  748. OriginalIndex is meaningless, rcptFlags are used seperately and there are
  749. currently none defined.
  750. */
  751. typedef IPMReadRecipientPB IPMReadReplyQueuePB;
  752.  
  753. struct IPMGetBlkIndexPB {
  754.     Ptr                                qLink;
  755.     long                            reservedH1;
  756.     long                            reservedH2;
  757.     IPMIOCompletionUPP                ioCompletion;
  758.     OSErr                            ioResult;
  759.     long                            saveA5;
  760.     short                            reqCode;
  761.     IPMMsgRef                        msgRef;
  762.     IPMBlockType                    blockType;
  763.     unsigned short                    index;
  764.     unsigned short                    startingFrom;
  765.     IPMBlockType                    actualBlockType;
  766.     unsigned short                    actualBlockIndex;
  767. };
  768. typedef struct IPMGetBlkIndexPB IPMGetBlkIndexPB;
  769.  
  770. struct IPMReadMsgPB {
  771.     Ptr                                qLink;
  772.     long                            reservedH1;
  773.     long                            reservedH2;
  774.     IPMIOCompletionUPP                ioCompletion;
  775.     OSErr                            ioResult;
  776.     long                            saveA5;
  777.     short                            reqCode;
  778.     IPMMsgRef                        msgRef;
  779.     IPMAccessMode                    mode;
  780.     long                            offset;
  781.     unsigned long                    count;
  782.     Ptr                                buffer;
  783.     unsigned long                    actualCount;
  784.     unsigned short                    blockIndex;
  785.     unsigned long                    remaining;
  786. };
  787. typedef struct IPMReadMsgPB IPMReadMsgPB;
  788.  
  789. struct IPMVerifySignaturePB {
  790.     Ptr                                qLink;
  791.     long                            reservedH1;
  792.     long                            reservedH2;
  793.     IPMIOCompletionUPP                ioCompletion;
  794.     OSErr                            ioResult;
  795.     long                            saveA5;
  796.     short                            reqCode;
  797.     IPMMsgRef                        msgRef;
  798.     SIGContextPtr                    signatureContext;
  799. };
  800. typedef struct IPMVerifySignaturePB IPMVerifySignaturePB;
  801.  
  802. struct IPMNewMsgPB {
  803.     Ptr                                qLink;
  804.     long                            reservedH1;
  805.     long                            reservedH2;
  806.     IPMIOCompletionUPP                ioCompletion;
  807.     OSErr                            ioResult;
  808.     long                            saveA5;
  809.     short                            reqCode;
  810.     unsigned long                    filler;
  811.     OCERecipient                    *recipient;
  812.     OCERecipient                    *replyQueue;
  813.     StringPtr                        procHint;
  814.     unsigned short                    filler2;
  815.     IPMMsgType                        *msgType;
  816.     unsigned long                    refCon;
  817.     IPMMsgRef                        newMsgRef;
  818.     unsigned short                    filler3;
  819.     long                            filler4;
  820.     AuthIdentity                    identity;
  821.     IPMSender                        *sender;
  822.     unsigned long                    internalUse;
  823.     unsigned long                    internalUse2;
  824. };
  825. typedef struct IPMNewMsgPB IPMNewMsgPB;
  826.  
  827. struct IPMNewHFSMsgPB {
  828.     Ptr                                qLink;
  829.     long                            reservedH1;
  830.     long                            reservedH2;
  831.     IPMIOCompletionUPP                ioCompletion;
  832.     OSErr                            ioResult;
  833.     long                            saveA5;
  834.     short                            reqCode;
  835.     FSSpec                            *hfsPath;
  836.     OCERecipient                    *recipient;
  837.     OCERecipient                    *replyQueue;
  838.     StringPtr                        procHint;
  839.     unsigned short                    filler2;
  840.     IPMMsgType                        *msgType;
  841.     unsigned long                    refCon;
  842.     IPMMsgRef                        newMsgRef;
  843.     unsigned short                    filler3;
  844.     long                            filler4;
  845.     AuthIdentity                    identity;
  846.     IPMSender                        *sender;
  847.     unsigned long                    internalUse;
  848.     unsigned long                    internalUse2;
  849. };
  850. typedef struct IPMNewHFSMsgPB IPMNewHFSMsgPB;
  851.  
  852. struct IPMNestMsgPB {
  853.     Ptr                                qLink;
  854.     long                            reservedH1;
  855.     long                            reservedH2;
  856.     IPMIOCompletionUPP                ioCompletion;
  857.     OSErr                            ioResult;
  858.     long                            saveA5;
  859.     short                            reqCode;
  860.     IPMMsgRef                        msgRef;
  861.     unsigned short                    filler[9];
  862.     unsigned long                    refCon;
  863.     IPMMsgRef                        msgToNest;
  864.     unsigned short                    filler2;
  865.     long                            startingOffset;
  866. };
  867. typedef struct IPMNestMsgPB IPMNestMsgPB;
  868.  
  869. struct IPMNewNestedMsgBlockPB {
  870.     Ptr                                qLink;
  871.     long                            reservedH1;
  872.     long                            reservedH2;
  873.     IPMIOCompletionUPP                ioCompletion;
  874.     OSErr                            ioResult;
  875.     long                            saveA5;
  876.     short                            reqCode;
  877.     IPMMsgRef                        msgRef;
  878.     OCERecipient                    *recipient;
  879.     OCERecipient                    *replyQueue;
  880.     StringPtr                        procHint;
  881.     unsigned short                    filler1;
  882.     IPMMsgType                        *msgType;
  883.     unsigned long                    refCon;
  884.     IPMMsgRef                        newMsgRef;
  885.     unsigned short                    filler2;
  886.     long                            startingOffset;
  887.     AuthIdentity                    identity;
  888.     IPMSender                        *sender;
  889.     unsigned long                    internalUse;
  890.     unsigned long                    internalUse2;
  891. };
  892. typedef struct IPMNewNestedMsgBlockPB IPMNewNestedMsgBlockPB;
  893.  
  894. struct IPMEndMsgPB {
  895.     Ptr                                qLink;
  896.     long                            reservedH1;
  897.     long                            reservedH2;
  898.     IPMIOCompletionUPP                ioCompletion;
  899.     OSErr                            ioResult;
  900.     long                            saveA5;
  901.     short                            reqCode;
  902.     IPMMsgRef                        msgRef;
  903.     IPMMsgID                        msgID;
  904.     RString                            *msgTitle;
  905.     IPMNotificationType                deliveryNotification;
  906.     IPMPriority                        priority;
  907.     Boolean                            cancel;
  908.     Byte                            padByte;
  909.     long                            reserved;
  910.     SIGSignaturePtr                    signature;
  911.     Size                            signatureSize;
  912.     SIGContextPtr                    signatureContext;
  913. /* family this msg belongs (e.g. mail) use kIPMFamilyUnspecified by default */
  914.     OSType                            family;
  915. };
  916. typedef struct IPMEndMsgPB IPMEndMsgPB;
  917.  
  918. struct IPMAddRecipientPB {
  919.     Ptr                                qLink;
  920.     long                            reservedH1;
  921.     long                            reservedH2;
  922.     IPMIOCompletionUPP                ioCompletion;
  923.     OSErr                            ioResult;
  924.     long                            saveA5;
  925.     short                            reqCode;
  926.     IPMMsgRef                        msgRef;
  927.     OCERecipient                    *recipient;
  928.     long                            reserved;
  929. };
  930. typedef struct IPMAddRecipientPB IPMAddRecipientPB;
  931.  
  932. struct IPMAddReplyQueuePB {
  933.     Ptr                                qLink;
  934.     long                            reservedH1;
  935.     long                            reservedH2;
  936.     IPMIOCompletionUPP                ioCompletion;
  937.     OSErr                            ioResult;
  938.     long                            saveA5;
  939.     short                            reqCode;
  940.     IPMMsgRef                        msgRef;
  941.     long                            filler;
  942.     OCERecipient                    *replyQueue;
  943. };
  944. typedef struct IPMAddReplyQueuePB IPMAddReplyQueuePB;
  945.  
  946. struct IPMNewBlockPB {
  947.     Ptr                                qLink;
  948.     long                            reservedH1;
  949.     long                            reservedH2;
  950.     IPMIOCompletionUPP                ioCompletion;
  951.     OSErr                            ioResult;
  952.     long                            saveA5;
  953.     short                            reqCode;
  954.     IPMMsgRef                        msgRef;
  955.     IPMBlockType                    blockType;
  956.     unsigned short                    filler[5];
  957.     unsigned long                    refCon;
  958.     unsigned short                    filler2[3];
  959.     long                            startingOffset;
  960. };
  961. typedef struct IPMNewBlockPB IPMNewBlockPB;
  962.  
  963. struct IPMWriteMsgPB {
  964.     Ptr                                qLink;
  965.     long                            reservedH1;
  966.     long                            reservedH2;
  967.     IPMIOCompletionUPP                ioCompletion;
  968.     OSErr                            ioResult;
  969.     long                            saveA5;
  970.     short                            reqCode;
  971.     IPMMsgRef                        msgRef;
  972.     IPMAccessMode                    mode;
  973.     long                            offset;
  974.     unsigned long                    count;
  975.     Ptr                                buffer;
  976.     unsigned long                    actualCount;
  977.     Boolean                            currentBlock;
  978.     Boolean                            filler1;
  979. };
  980. typedef struct IPMWriteMsgPB IPMWriteMsgPB;
  981.  
  982. union IPMParamBlock {
  983.     struct {
  984.         Ptr                                qLink;
  985.         long                            reservedH1;
  986.         long                            reservedH2;
  987.         IPMIOCompletionUPP                ioCompletion;
  988.         OSErr                            ioResult;
  989.         long                            saveA5;
  990.         short                            reqCode;
  991.     }                                header;
  992.     IPMOpenContextPB                openContextPB;
  993.     IPMCloseContextPB                closeContextPB;
  994.     IPMCreateQueuePB                createQueuePB;
  995.     IPMDeleteQueuePB                deleteQueuePB;
  996.     IPMOpenQueuePB                    openQueuePB;
  997.     IPMCloseQueuePB                    closeQueuePB;
  998.     IPMEnumerateQueuePB                enumerateQueuePB;
  999.     IPMChangeQueueFilterPB            changeQueueFilterPB;
  1000.     IPMDeleteMsgRangePB                deleteMsgRangePB;
  1001.     IPMOpenMsgPB                    openMsgPB;
  1002.     IPMOpenHFSMsgPB                    openHFSMsgPB;
  1003.     IPMOpenBlockAsMsgPB                openBlockAsMsgPB;
  1004.     IPMCloseMsgPB                    closeMsgPB;
  1005.     IPMGetMsgInfoPB                    getMsgInfoPB;
  1006.     IPMReadHeaderPB                    readHeaderPB;
  1007.     IPMReadRecipientPB                readRecipientPB;
  1008.     IPMReadReplyQueuePB                readReplyQueuePB;
  1009.     IPMGetBlkIndexPB                getBlkIndexPB;
  1010.     IPMReadMsgPB                    readMsgPB;
  1011.     IPMVerifySignaturePB            verifySignaturePB;
  1012.     IPMNewMsgPB                        newMsgPB;
  1013.     IPMNewHFSMsgPB                    newHFSMsgPB;
  1014.     IPMNestMsgPB                    nestMsgPB;
  1015.     IPMNewNestedMsgBlockPB            newNestedMsgBlockPB;
  1016.     IPMEndMsgPB                        endMsgPB;
  1017.     IPMAddRecipientPB                addRecipientPB;
  1018.     IPMAddReplyQueuePB                addReplyQueuePB;
  1019.     IPMNewBlockPB                    newBlockPB;
  1020.     IPMWriteMsgPB                    writeMsgPB;
  1021. };
  1022. enum {
  1023.     uppIPMIOCompletionProcInfo = kPascalStackBased
  1024.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(IPMParamBlockPtr)))
  1025. };
  1026.  
  1027. #if GENERATINGCFM
  1028. #define CallIPMIOCompletionProc(userRoutine, paramBlock)        \
  1029.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppIPMIOCompletionProcInfo, (paramBlock))
  1030. #else
  1031. #define CallIPMIOCompletionProc(userRoutine, paramBlock)        \
  1032.         (*(userRoutine))((paramBlock))
  1033. #endif
  1034.  
  1035. #if GENERATINGCFM
  1036. #define NewIPMIOCompletionProc(userRoutine)        \
  1037.         (IPMIOCompletionUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppIPMIOCompletionProcInfo, GetCurrentArchitecture())
  1038. #else
  1039. #define NewIPMIOCompletionProc(userRoutine)        \
  1040.         ((IPMIOCompletionUPP) (userRoutine))
  1041. #endif
  1042.  
  1043. /*    Request codes */
  1044. #define kIPMOpenContext 0x400
  1045. #define kIPMCloseContext 0x401
  1046. #define kIPMNewMsg 0x402
  1047. #define kIPMAddRecipient 0x403
  1048. #define kIPMNewBlock 0x404
  1049. #define kIPMNewNestedMsgBlock 0x405
  1050. #define kIPMNestMsg 0x406
  1051. #define kIPMWriteMsg 0x407
  1052. #define kIPMEndMsg 0x408
  1053. #define kIPMOpenQueue 0x409
  1054. #define kIPMCloseQueue 0x40A
  1055. #define kIPMOpenMsg 0x40B
  1056. #define kIPMCloseMsg 0x40C
  1057. #define kIPMReadMsg 0x40D
  1058. #define kIPMReadHeader 0x40E
  1059. #define kIPMOpenBlockAsMsg 0x40F
  1060. #define kIPMReadRecipient 0x410
  1061. #define kIPMCreateQueue 0x411
  1062. #define kIPMDeleteQueue 0x412
  1063. #define kIPMEnumerateQueue 0x413
  1064. #define kIPMChangeQueueFilter 0x414
  1065. #define kIPMDeleteMsgRange 0x415
  1066. #define kIPMOpenHFSMsg 0x417
  1067. #define kIPMGetBlkIndex 0x418
  1068. #define kIPMGetMsgInfo 0x419
  1069. #define kIPMAddReplyQueue 0x41D
  1070. #define kIPMNewHFSMsg 0x41E
  1071. #define kIPMReadReplyQueue 0x421
  1072. #define kIPMVerifySignature 0x422
  1073. extern pascal OSErr IPMOpenContext(IPMParamBlockPtr paramBlock, Boolean async)
  1074.  THREEWORDINLINE(0x3F3C, 0x400, 0xAA5E);
  1075. extern pascal OSErr IPMCloseContext(IPMParamBlockPtr paramBlock, Boolean async)
  1076.  THREEWORDINLINE(0x3F3C, 0x401, 0xAA5E);
  1077. extern pascal OSErr IPMNewMsg(IPMParamBlockPtr paramBlock, Boolean async)
  1078.  THREEWORDINLINE(0x3F3C, 0x402, 0xAA5E);
  1079. extern pascal OSErr IPMNewBlock(IPMParamBlockPtr paramBlock, Boolean async)
  1080.  THREEWORDINLINE(0x3F3C, 0x404, 0xAA5E);
  1081. extern pascal OSErr IPMNewNestedMsgBlock(IPMParamBlockPtr paramBlock, Boolean async)
  1082.  THREEWORDINLINE(0x3F3C, 0x405, 0xAA5E);
  1083. extern pascal OSErr IPMNestMsg(IPMParamBlockPtr paramBlock, Boolean async)
  1084.  THREEWORDINLINE(0x3F3C, 0x406, 0xAA5E);
  1085. extern pascal OSErr IPMWriteMsg(IPMParamBlockPtr paramBlock, Boolean async)
  1086.  THREEWORDINLINE(0x3F3C, 0x407, 0xAA5E);
  1087. extern pascal OSErr IPMEndMsg(IPMParamBlockPtr paramBlock, Boolean async)
  1088.  THREEWORDINLINE(0x3F3C, 0x408, 0xAA5E);
  1089. extern pascal OSErr IPMOpenQueue(IPMParamBlockPtr paramBlock, Boolean async)
  1090.  THREEWORDINLINE(0x3F3C, 0x409, 0xAA5E);
  1091. extern pascal OSErr IPMCloseQueue(IPMParamBlockPtr paramBlock, Boolean async)
  1092.  THREEWORDINLINE(0x3F3C, 0x40A, 0xAA5E);
  1093. /* Always synchronous */
  1094. extern pascal OSErr IPMVerifySignature(IPMParamBlockPtr paramBlock)
  1095.  FIVEWORDINLINE(0x7000, 0x1f00, 0x3F3C, 0x422, 0xAA5E);
  1096. extern pascal OSErr IPMOpenMsg(IPMParamBlockPtr paramBlock, Boolean async)
  1097.  THREEWORDINLINE(0x3F3C, 0x40B, 0xAA5E);
  1098. extern pascal OSErr IPMCloseMsg(IPMParamBlockPtr paramBlock, Boolean async)
  1099.  THREEWORDINLINE(0x3F3C, 0x40C, 0xAA5E);
  1100. extern pascal OSErr IPMReadMsg(IPMParamBlockPtr paramBlock, Boolean async)
  1101.  THREEWORDINLINE(0x3F3C, 0x40D, 0xAA5E);
  1102. extern pascal OSErr IPMReadHeader(IPMParamBlockPtr paramBlock, Boolean async)
  1103.  THREEWORDINLINE(0x3F3C, 0x40E, 0xAA5E);
  1104. extern pascal OSErr IPMOpenBlockAsMsg(IPMParamBlockPtr paramBlock, Boolean async)
  1105.  THREEWORDINLINE(0x3F3C, 0x40F, 0xAA5E);
  1106. extern pascal OSErr IPMNewHFSMsg(IPMParamBlockPtr paramBlock, Boolean async)
  1107.  THREEWORDINLINE(0x3F3C, 0x41E, 0xAA5E);
  1108. extern pascal OSErr IPMReadRecipient(IPMParamBlockPtr paramBlock, Boolean async)
  1109.  THREEWORDINLINE(0x3F3C, 0x410, 0xAA5E);
  1110. extern pascal OSErr IPMReadReplyQueue(IPMParamBlockPtr paramBlock, Boolean async)
  1111.  THREEWORDINLINE(0x3F3C, 0x421, 0xAA5E);
  1112. extern pascal OSErr IPMCreateQueue(IPMParamBlockPtr paramBlock, Boolean async)
  1113.  THREEWORDINLINE(0x3F3C, 0x411, 0xAA5E);
  1114. extern pascal OSErr IPMDeleteQueue(IPMParamBlockPtr paramBlock, Boolean async)
  1115.  THREEWORDINLINE(0x3F3C, 0x412, 0xAA5E);
  1116. extern pascal OSErr IPMEnumerateQueue(IPMParamBlockPtr paramBlock, Boolean async)
  1117.  THREEWORDINLINE(0x3F3C, 0x413, 0xAA5E);
  1118. extern pascal OSErr IPMChangeQueueFilter(IPMParamBlockPtr paramBlock, Boolean async)
  1119.  THREEWORDINLINE(0x3F3C, 0x414, 0xAA5E);
  1120. extern pascal OSErr IPMDeleteMsgRange(IPMParamBlockPtr paramBlock, Boolean async)
  1121.  THREEWORDINLINE(0x3F3C, 0x415, 0xAA5E);
  1122. extern pascal OSErr IPMAddRecipient(IPMParamBlockPtr paramBlock, Boolean async)
  1123.  THREEWORDINLINE(0x3F3C, 0x403, 0xAA5E);
  1124. extern pascal OSErr IPMAddReplyQueue(IPMParamBlockPtr paramBlock, Boolean async)
  1125.  THREEWORDINLINE(0x3F3C, 0x41D, 0xAA5E);
  1126. extern pascal OSErr IPMOpenHFSMsg(IPMParamBlockPtr paramBlock, Boolean async)
  1127.  THREEWORDINLINE(0x3F3C, 0x417, 0xAA5E);
  1128. extern pascal OSErr IPMGetBlkIndex(IPMParamBlockPtr paramBlock, Boolean async)
  1129.  THREEWORDINLINE(0x3F3C, 0x418, 0xAA5E);
  1130. extern pascal OSErr IPMGetMsgInfo(IPMParamBlockPtr paramBlock, Boolean async)
  1131.  THREEWORDINLINE(0x3F3C, 0x419, 0xAA5E);
  1132.  
  1133. #if PRAGMA_IMPORT_SUPPORTED
  1134. #pragma import off
  1135. #endif
  1136.  
  1137. #if PRAGMA_ALIGN_SUPPORTED
  1138. #pragma options align=reset
  1139. #endif
  1140.  
  1141. #ifdef __cplusplus
  1142. }
  1143. #endif
  1144.  
  1145. #endif /* __OCEMESSAGING__ */
  1146.